#-*- coding: UTF-8 -*-
from pyramid.httpexceptions import HTTPFound
from pyramid.security import remember
from pyramid.security import forget

from sqlalchemy import and_
from sqlalchemy import or_
from sqlalchemy.orm import eagerload


from scp.modelo.models import DBSession
from scp.modelo.Tipo_Item import Tipo_Item
from scp.modelo.Rol import Rol
from scp.modelo.Permiso import Permiso
from scp.modelo.Item import Item
from scp.modelo.Fase import Fase
from scp.modelo.ValoresCadena import ValoresCadena
from scp.modelo.ValoresNumerico import ValoresNumerico
from scp.modelo.ValoresFecha import ValoresFecha
from scp.modelo.ValoresArchivo import ValoresArchivo
from scp.modelo.RelacionP_H import RelacionP_H
from scp.modelo.RelacionA_S import RelacionA_S

from pyramid.response import Response
from pyramid.view import view_config
import json

import re

session = DBSession()
#@view_config(renderer='json')
def relaciones(request):
	"""Método controlador encargado de la administración de las relaciones.
		URL asociada: /relaciones/{operacion}
		operacion:
			traerItems: retorna los items a relacionar de acuerdo al tipo de relacion
		@param request: Petición Http del cliente. 	
	"""
	
	methodRequest = request.method
		
	dicParametros = request.matchdict
	

	if dicParametros.get('operacion') == 'crear' and request.url.find('?') == -1:
		print 'respondí un diccionario normal'
		return {'content':'Hello!'}	
	
	
	
	if dicParametros.get('operacion') == 'traerItemsCrear':
		tipoRelacion = request.params['tipoRelacion']
		nombreProyecto = request.params['nombreProyecto']
		idFase = request.params['idFase']
		idItem = request.params['idItem']
		print 'Este es el id de la fase:'
		print idFase
		
		response = Response()
		if tipoRelacion == 'Padre - Hijo':
			hijo = session.query(RelacionP_H).filter_by(hijo = idItem).first()
			
			'''itemElegido = session.query(Item).filter_by(id = idItem).first()
			if itemElegido.estado == 'BLOQUEADO':
				items = session.query(Item).filter(and_(Item.fase_id==request.params['idFase'], Item.flagUltimo == 1, Item.flagBorrado == 0, Item.id != idItem)).filter(Item.estado == 'BLOQUEADO').all()
			else:
				items = session.query(Item).filter(and_(Item.fase_id==request.params['idFase'], Item.flagUltimo == 1, Item.flagBorrado == 0, Item.id != idItem)).filter(or_(Item.estado == 'APROBADO', Item.estado == 'BLOQUEADO')).all()'''
			
			items = session.query(Item).filter(and_(Item.fase_id==request.params['idFase'], Item.flagUltimo == 1, Item.flagBorrado == 0, Item.id != idItem)).all()
			padresArray = []
			if hijo is None:
				for item in items:
					aux = {'idItem':item.id, 'nombreItem':item.nombre}
					padresArray.append(aux)
			response.body = json.dumps(dict(success = True, items = padresArray))
			
		else:
			fase = session.query(Fase).filter_by(id = idFase).first()
			proyectoID = fase.proyecto_id
			antecesoresArray = []
			if fase.orden > 1:
				faseAnterior = session.query(Fase).filter_by(orden = fase.orden - 1, proyecto_id = proyectoID).first()
				items = session.query(Item).filter(and_(Item.fase_id==faseAnterior.id, Item.flagUltimo == 1, Item.flagBorrado == 0, Item.id != idItem, Item.estado == 'BLOQUEADO')).all()
				print '>>>len(items)'
				print len(items)
				for item in items:
					aux = {'idItem':item.id, 'nombreItem':item.nombre}
					antecesoresArray.append(aux)
			response.body = json.dumps(dict(success = True, items = antecesoresArray))
				
		response.content_type = 'application/json'
		
		return response

	if dicParametros.get('operacion') == 'traerItem':
		idItem = request.params['idItem']
		item = session.query(Item).filter_by(id = idItem).first()
		
		response = Response()
		response.body = json.dumps(dict(success = True, item = {'codItem': item.codigo, 'nombreItem': item.nombre, 'versionItem': item.version}))
		response.content_type = 'application/json'
		
		return response
	
	if dicParametros.get('operacion') == 'view':
		idItem = request.params['idItem']
		relacionesArray = []

		print ">>>request.params['idItem'] en relaciones"
		print request.params['idItem']

		tipoRelacion = 'Padre-Hijo'
		relaciones = session.query(RelacionP_H).filter(or_(RelacionP_H.padre == idItem, RelacionP_H.hijo == idItem)).all()
		for relacion in relaciones:
			duenho = None
			padre = session.query(Item).filter_by(id = relacion.padre, flagUltimo = 1, flagBorrado = 0).first()
			hijo = session.query(Item).filter_by(id = relacion.hijo, flagUltimo = 1, flagBorrado = 0).first()
			duenho = session.query(Item).filter_by(id = relacion.duenho, flagUltimo = 1, flagBorrado = 0).first()
			
			if (hijo is not None) and (padre is not None):
				if str(duenho.id) == str(idItem):
					duenho = True
					item = padre.nombre
					
				else:
					duenho = False
					item = hijo.nombre
					
					
			
				aux = {'idRelacion': relacion.id, 'item':item, 'tipoRelacion':tipoRelacion, 'duenho': duenho}
				relacionesArray.append(aux)
		
		tipoRelacion = 'Antecesor-Sucesor'
		relaciones = session.query(RelacionA_S).filter(or_(RelacionA_S.antecesor == idItem, RelacionA_S.sucesor == idItem)).all()
		for relacion in relaciones:
			duenho = None
			antecesor = session.query(Item).filter_by(id = relacion.antecesor, flagUltimo = 1, flagBorrado = 0).first()
			sucesor = session.query(Item).filter_by(id = relacion.sucesor, flagUltimo = 1, flagBorrado = 0).first()
			duenho = session.query(Item).filter_by(id = relacion.duenho, flagUltimo = 1, flagBorrado = 0).first()
			
			if (antecesor is not None) and (sucesor is not None):
				if str(duenho.id) == str(idItem):
					duenho = True
					item = antecesor.nombre
					
				else:
					duenho = False
					item = sucesor.nombre
					
				
				aux = {'idRelacion': relacion.id, 'item':item, 'tipoRelacion':tipoRelacion, 'duenho': duenho}
				relacionesArray.append(aux)
			
		response = Response()
		response.body = json.dumps(dict(success = True, relaciones = relacionesArray))
		response.content_type = 'application/json'
		
		return response
		
	if dicParametros.get('operacion') == 'create':
		tipoRelacion = request.params['tipoRelacion']
		idItem = request.params['idItem']
		idItemRelacionar = request.params['idItemRelacionar']
		
		response = Response()
		if tipoRelacion == 'Padre - Hijo':
			ciclo = comprobar_ciclos(idItem, idItemRelacionar)
			print 'ciclo'
			print ciclo
			if (ciclo == True):
				response.body = json.dumps(dict(success = False, msg = 'No se puede crear la relacion, se formara un ciclo!!!'))
			else:
				#generamos una nueva version del item
				itemNewVersion = reversionarItem(idItem)
				#regeneramos la relaciones anteriores del item
				reproducir_relacionesCrearRelacionPadreHijo(idItem, itemNewVersion.id, False,session)
				
				#agregamos la nueva relacion al nuevo item versionado
				relacionP_H = RelacionP_H()
				relacionP_H.padre = idItemRelacionar
				relacionP_H.hijo = itemNewVersion.id
				relacionP_H.duenho = itemNewVersion.id
				
				session.add(relacionP_H)
				
				#marcamos a revision los item relacionados
				marcar_item_to_revision(itemNewVersion.id)
				
				response.body = json.dumps(dict(success = True, idNuevoItem = itemNewVersion.id))
			
		else:
			existe_relacion = session.query(RelacionA_S).filter_by(antecesor = idItemRelacionar, sucesor = idItem).first()
			if (not existe_relacion):
				#generamos una nueva version del item
				itemNewVersion = reversionarItem(idItem)
				#regeneramos la relaciones anteriores del item
				reproducir_relacionesCrearRelacionAntecesorSucesor(idItem, itemNewVersion.id, session)
				
				#ahora agregamos de verdad la relacion
				relacionA_S = RelacionA_S()
				relacionA_S.antecesor = idItemRelacionar
				relacionA_S.sucesor = itemNewVersion.id
				relacionA_S.duenho = itemNewVersion.id
			
				session.add(relacionA_S)
				#marcamos a revision los item relacionados
				marcar_item_to_revision(itemNewVersion.id)
				
				response.body = json.dumps(dict(success = True, idNuevoItem = itemNewVersion.id))
			else:
				response.body = json.dumps(dict(success = False, msg = 'No se puede crear la relacion, ya existe!!!'))
				
		response.content_type = 'application/json'
		
		return response
		
	if dicParametros.get('operacion') == 'traerItemsEditar':
		tipoRelacion = request.params['tipoRelacion']
		nombreProyecto = request.params['nombreProyecto']
		idFase = request.params['idFase']
		idItem = request.params['idItem']
		
		response = Response()
		if tipoRelacion == 'Padre - Hijo':
			
			'''itemElegido = session.query(Item).filter_by(id = idItem).first()
			if itemElegido.estado == 'BLOQUEADO':
				items = session.query(Item).filter(and_(Item.fase_id==request.params['idFase'], Item.flagUltimo == 1, Item.flagBorrado == 0, Item.id != idItem)).filter(Item.estado == 'BLOQUEADO').all()
			else:
				items = session.query(Item).filter(and_(Item.fase_id==request.params['idFase'], Item.flagUltimo == 1, Item.flagBorrado == 0, Item.id != idItem)).filter(or_(Item.estado == 'APROBADO', Item.estado == 'BLOQUEADO')).all()'''
			
			items = session.query(Item).filter(and_(Item.fase_id==request.params['idFase'], Item.flagUltimo == 1, Item.flagBorrado == 0, Item.id != idItem)).all()	
			padresArray = []
			for item in items:
				aux = {'idItem':item.id, 'nombreItem':item.nombre}
				padresArray.append(aux)
			response.body = json.dumps(dict(success = True, items = padresArray))
			
		else:
			fase = session.query(Fase).filter_by(id = idFase).first()
			proyectoID = fase.proyecto_id
			antecesoresArray = []
			if fase.orden > 1:
				faseAnterior = session.query(Fase).filter_by(orden = fase.orden - 1, proyecto_id = proyectoID).first()
				items = session.query(Item).filter(and_(Item.fase_id==faseAnterior.id, Item.flagUltimo == 1, Item.flagBorrado == 0, Item.id != idItem, Item.estado == 'BLOQUEADO')).all()
				for item in items:
					aux = {'idItem':item.id, 'nombreItem':item.nombre}
					antecesoresArray.append(aux)
			response.body = json.dumps(dict(success = True, items = antecesoresArray))
				
		response.content_type = 'application/json'
		
		return response
	
	if dicParametros.get('operacion') == 'edit':
		tipoRelacion = request.params['tipoRelacion']
		idItemRelacionar = request.params['idItemRelacionar']
		idRelacion = request.params['idRelacion']
		idItem = request.params['idItem']
		
		response = Response()
		if tipoRelacion == 'Padre - Hijo':
			ciclo = comprobar_ciclos(idItem, idItemRelacionar)
			if (ciclo == True):
				response.body = json.dumps(dict(success = False, msg = 'No se puede editar la relacion, se formara un ciclo!!!'))
			else:
				#traemos la relacion original
				relacionP_H = session.query(RelacionP_H).filter_by(id = idRelacion).first()
				padreOriginal = relacionP_H.padre
				
				#generamos una nueva version del item para guardar la edicion
				itemNewVersion = reversionarItem(idItem)
				#regeneramos la relaciones anteriores del item
				reproducir_relacionesCrearRelacionPadreHijo(idItem, itemNewVersion.id,True, session)
				
				#traemos la relacion para editarlo en la nueva version
				relacionP_HEditar = session.query(RelacionP_H).filter_by(padre = padreOriginal, hijo = itemNewVersion.id, duenho = itemNewVersion.id ).first()
				relacionP_HEditar.padre = idItemRelacionar
				
				#marcamos a revision los item relacionados
				marcar_item_to_revision(itemNewVersion.id)
				
				response.body = json.dumps(dict(success = True, idNuevoItem = itemNewVersion.id))
			
		else:
			existe_relacion = session.query(RelacionA_S).filter_by(antecesor = idItemRelacionar, sucesor = idItem).first()
			if (not existe_relacion):
				
				#traemos la relacion original
				relacionA_S = session.query(RelacionA_S).filter_by(id = idRelacion).first()
				antecesorOriginal = relacionA_S.antecesor
				
				#generamos una nueva version del item para guardar la edicion
				itemNewVersion = reversionarItem(idItem)
				#regeneramos la relaciones anteriores del item
				reproducir_relacionesCrearRelacionAntecesorSucesor(idItem, itemNewVersion.id, session)
				
				#traemos la relacion para editarlo en la nueva version
				relacionA_SEditar = session.query(RelacionA_S).filter_by(antecesor = antecesorOriginal, sucesor = itemNewVersion.id, duenho = itemNewVersion.id ).first()
				relacionA_SEditar.antecesor = idItemRelacionar
				
				#marcamos a revision los item relacionados
				marcar_item_to_revision(itemNewVersion.id)
				
				'''relacionA_S = session.query(RelacionA_S).filter_by(id = idRelacion).first()
				relacionA_S.antecesor = idItemRelacionar'''
				response.body = json.dumps(dict(success = True, idNuevoItem = itemNewVersion.id))
			else:
				response.body = json.dumps(dict(success = False, msg = 'No se puede editar la relacion, ya existe!!!'))	
				
		response.content_type = 'application/json'
		
		return response
	
	if dicParametros.get('operacion') == 'delete':
		tipoRelacion = request.params['tipoRelacion']
		idRelacion = request.params['idRelacion']
		
		print ">>>id de item a eliminar"
		print idRelacion
		
		response = Response()
		borrado = 'NO'
		if tipoRelacion == 'Padre-Hijo':
			relacionBorrar = session.query(RelacionP_H).filter_by(id = idRelacion ).first()
			hijo = session.query(Item).filter_by(id = relacionBorrar.hijo ).first()
			fase = session.query(Fase).filter_by(id = hijo.fase_id ).first()
			if fase.orden > 1:
				if hijo.estado == 'BLOQUEADO' or hijo.estado == 'APROBADO':
					antecesores = session.query(RelacionA_S.antecesor).filter_by(sucesor = hijo.id ).all()
					for antecesor in antecesores:
						tieneAntecesorActual = session.query(Item).filter_by(id = antecesor[0], flagUltimo = 1, flagBorrado = 0).first()
						if tieneAntecesorActual is not None:
							#guardamos el padre a borrar
							padreABorrar = relacionBorrar.padre
							
							#generamos una nueva version del item para guardar la edicion
							itemNewVersion = reversionarItem(relacionBorrar.hijo)
							#regeneramos la relaciones anteriores del item
							reproducir_relacionesCrearRelacionPadreHijo(relacionBorrar.hijo, itemNewVersion.id, True,session)
							
							#ahora traemos la relacion a borrar pero del item reversionado
							relacionDelItemVers = session.query(RelacionP_H).filter_by(padre = padreABorrar, hijo = itemNewVersion.id ).first()
							#borramos la relacion pero del item versionado
							session.delete(relacionDelItemVers)
							
							#marcamos a revision los item relacionados
							marcar_item_to_revision(itemNewVersion.id)
							
							response.body = json.dumps(dict(success = True, idNuevoItem = itemNewVersion.id))
							borrado = 'SI'
							break 
				else:
					#session.delete(relacionBorrar)
					#guardamos el padre a borrar
					padreABorrar = relacionBorrar.padre
					
					#generamos una nueva version del item para guardar la edicion
					itemNewVersion = reversionarItem(relacionBorrar.hijo)
					#regeneramos la relaciones anteriores del item
					reproducir_relacionesCrearRelacionPadreHijo(relacionBorrar.hijo, itemNewVersion.id, True,session)
					
					#ahora traemos la relacion a borrar pero del item reversionado
					print '>>>>>>padreABorrar'
					print padreABorrar
					print '>>>>>>itemNewVersion.id'
					print itemNewVersion.id
					relacionDelItemVers = session.query(RelacionP_H).filter_by(padre = padreABorrar, hijo = itemNewVersion.id ).first()
					print '>>>>>>relacionDelItemVers'
					print relacionDelItemVers
					
					#borramos la relacion pero del item versionado
					session.delete(relacionDelItemVers)
					
					#marcamos a revision los item relacionados
					marcar_item_to_revision(itemNewVersion.id)
					
					response.body = json.dumps(dict(success = True, idNuevoItem = itemNewVersion.id))
					borrado = 'SI'
			else:
				#session.delete(relacionBorrar)
				#guardamos el padre a borrar
				padreABorrar = relacionBorrar.padre
				
				#generamos una nueva version del item para guardar la edicion
				itemNewVersion = reversionarItem(relacionBorrar.hijo)
				#regeneramos la relaciones anteriores del item
				reproducir_relacionesCrearRelacionPadreHijo(relacionBorrar.hijo, itemNewVersion.id, True,session)
				
				#ahora traemos la relacion a borrar pero del item reversionado
				relacionDelItemVers = session.query(RelacionP_H).filter_by(padre = padreABorrar, hijo = itemNewVersion.id ).first()
				#borramos la relacion pero del item versionado
				session.delete(relacionDelItemVers)
				
				#marcamos a revision los item relacionados
				marcar_item_to_revision(itemNewVersion.id)
				
				response.body = json.dumps(dict(success = True, idNuevoItem = itemNewVersion.id))
				borrado = 'SI'
		else:
			relacionBorrar = session.query(RelacionA_S).filter_by(id = idRelacion ).first()
			sucesor = session.query(Item).filter_by(id = relacionBorrar.sucesor ).first()
			if sucesor.estado == 'BLOQUEADO' or sucesor.estado == 'APROBADO':
				padres = session.query(RelacionP_H.padre).filter_by(hijo = sucesor.id ).all()
				for padre in padres:
					tienePadreActual = session.query(Item).filter_by(id = padre[0], flagUltimo = 1, flagBorrado = 0).first()
					if tienePadreActual is not None:
						#session.delete(relacionBorrar)
						
						#guardamos el padre a borrar
						antecesorABorrar = relacionBorrar.antecesor
						
						#generamos una nueva version del item para guardar la edicion
						itemNewVersion = reversionarItem(relacionBorrar.sucesor)
						#regeneramos la relaciones anteriores del item
						reproducir_relacionesCrearRelacionAntecesorSucesor(relacionBorrar.sucesor, itemNewVersion.id, session)
						
						#ahora traemos la relacion a borrar pero del item reversionado
						relacionDelItemVers = session.query(RelacionA_S).filter_by(antecesor = antecesorABorrar, sucesor = itemNewVersion.id ).first()
						#borramos la relacion pero del item versionado
						session.delete(relacionDelItemVers)
						
						#marcamos a revision los item relacionados
						marcar_item_to_revision(itemNewVersion.id)
						
						response.body = json.dumps(dict(success = True, idNuevoItem = itemNewVersion.id))
						borrado = 'SI'
						break
				if borrado == 'NO':
					antecesores = session.query(RelacionA_S.antecesor).filter(RelacionA_S.sucesor == relacionBorrar.sucesor).filter(RelacionA_S.antecesor != relacionBorrar.antecesor).all()
					for antecesor in antecesores:
						tieneAntecesorActual = session.query(Item).filter_by(id = antecesor[0], flagUltimo = 1, flagBorrado = 0).first()
						if tieneAntecesorActual is not None:
							#session.delete(relacionBorrar)
							
							#guardamos el padre a borrar
							antecesorABorrar = relacionBorrar.antecesor
							
							#generamos una nueva version del item para guardar la edicion
							itemNewVersion = reversionarItem(relacionBorrar.sucesor)
							#regeneramos la relaciones anteriores del item
							reproducir_relacionesCrearRelacionAntecesorSucesor(relacionBorrar.sucesor, itemNewVersion.id, session)
							
							#ahora traemos la relacion a borrar pero del item reversionado
							relacionDelItemVers = session.query(RelacionA_S).filter_by(antecesor = antecesorABorrar, sucesor = itemNewVersion.id ).first()
							#borramos la relacion pero del item versionado
							session.delete(relacionDelItemVers)
							
							#marcamos a revision los item relacionados
							marcar_item_to_revision(itemNewVersion.id)
							
							response.body = json.dumps(dict(success = True, idNuevoItem = itemNewVersion.id))
							borrado = 'SI'
							break
			else:
				#session.delete(relacionBorrar)
				
				#guardamos el padre a borrar
				antecesorABorrar = relacionBorrar.antecesor
				
				#generamos una nueva version del item para guardar la edicion
				itemNewVersion = reversionarItem(relacionBorrar.sucesor)
				#regeneramos la relaciones anteriores del item
				reproducir_relacionesCrearRelacionAntecesorSucesor(relacionBorrar.sucesor, itemNewVersion.id, session)
				
				#ahora traemos la relacion a borrar pero del item reversionado
				relacionDelItemVers = session.query(RelacionA_S).filter_by(antecesor = antecesorABorrar, sucesor = itemNewVersion.id ).first()
				#borramos la relacion pero del item versionado
				session.delete(relacionDelItemVers)
				
				#marcamos a revision los item relacionados
				marcar_item_to_revision(itemNewVersion.id)
				
				response.body = json.dumps(dict(success = True, idNuevoItem = itemNewVersion.id))
				borrado = 'SI'
				

		if borrado == 'NO':
			response.body = json.dumps(dict(success = False, msg = 'No se puede eliminar la relacion, el item duenho de la misma quedara inconsistente!!!'))
		
		#responseView.body = json.dumps(dict(success = True, atributos = [{'nombre':'Nombre', 'tipo': 'Cadena'}, {'nombre':'Fecha Inicio', 'tipo': 'Fecha'}]))
		
		response.content_type = 'application/json'
		
		return response
		
	elif dicParametros.get('operacion') == 'viewEstadoItem':
		idItem = json.loads(request.params['idItem'])
		item = session.query(Item).filter_by(id=idItem).first()
		
		responseEstadoProyecto = Response()
		responseEstadoProyecto.body = json.dumps(dict(success = True, estado = item.estado))
		responseEstadoProyecto.content_type = 'application/json'
		return responseEstadoProyecto
			
def comprobar_ciclos(hijo, padre):
	
	session = DBSession()
	print 'hijo'
	print hijo
	print 'padre'
	print padre
	destinos_relaciones = session.query(RelacionP_H.padre).filter_by(hijo=padre).all()
	print 'destinos_relaciones'
	print destinos_relaciones
	retorno = False 
	
	for destino_relacion in destinos_relaciones:
		print 'destino_relacion'
		print destino_relacion[0]
		itemDestino = session.query(Item).filter_by(id=destino_relacion[0]).one()
		
		if itemDestino.flagUltimo == 1 and itemDestino.flagBorrado == 0:		
			if str(destino_relacion[0]) == str(hijo):
				print 'estoy en el caso base!!!'
				retorno = True
				break
			else:
				retorno = comprobar_ciclos(hijo, destino_relacion[0])
			
	return retorno


def reversionarItem(idItemEditado):
	
	#itemDic = json.loads(request.params['item'])
	
	#itemData = itemDic.get('data')
	
	nuevoItem = Item()
	itemEditado = session.query(Item).filter_by(id=idItemEditado).first()
	itemEditado.flagUltimo = 0
	

	#nombreProyecto = request.params['nombreProyecto']
	#nombreFase = request.params['nombreFase']
	
	#traemos el tipo de item
	tipoItem = itemEditado.tipoItem #session.query(Tipo_Item).filter_by(id = itemData.get('idTipoItem') ).first()
	nombreTipoItem = tipoItem.nombre


	nuevoItem.codigo = itemEditado.codigo
	nuevoItem.nombre = itemEditado.nombre
	nuevoItem.complejidad = itemEditado.complejidad #itemData.get('complejidadItem')
	nuevoItem.descripcion = itemEditado.descripcion #itemData.get('descripcionItem')
	nuevoItem.version = itemEditado.version + 1
	nuevoItem.flagUltimo = 1
	nuevoItem.estado = 'ACTIVO'
	nuevoItem.flagBorrado = 0
	
	#seteamos los flagas para modificación y revisición
	nuevoItem.flagRevisar = 0
	nuevoItem.flagModificar = itemEditado.flagModificar
	
	nuevoItem.tipoItem = tipoItem
	
	session.add( nuevoItem )
	
	#asignamos el item a la fase correspondiente
	fase = session.query(Fase).filter_by(id = itemEditado.fase_id ).first()
	fase.items.append(nuevoItem)
	
	#setemos los valores de atributo
	atributosCadena = session.query(ValoresCadena).filter_by(item_id=itemEditado.id).all() 	
	atributosFecha = session.query(ValoresFecha).filter_by(item_id=itemEditado.id).all()
	atributosNumerico = session.query(ValoresNumerico).filter_by(item_id=itemEditado.id).all()
	atributosArchivo = session.query(ValoresArchivo).filter_by(item_id=itemEditado.id).all()
	
	#vamos reversionando los atributos
	if len(atributosCadena) > 0: 
		for atributo in atributosCadena:
			nuevoAtributo = ValoresCadena()	
			nuevoAtributo.nombreAtributo = atributo.nombreAtributo
			nuevoAtributo.valor = atributo.valor
			nuevoAtributo.item_id = nuevoItem.id
			nuevoAtributo.version_item = nuevoItem.version
			session.add(nuevoAtributo)
		
			
	if len(atributosFecha) > 0:
		for atributo in atributosFecha:
			nuevoAtributo = ValoresFecha()	
			nuevoAtributo.nombreAtributo = atributo.nombreAtributo
			nuevoAtributo.valor = atributo.valor
			nuevoAtributo.item_id = nuevoItem.id
			nuevoAtributo.version_item = nuevoItem.version
			session.add(nuevoAtributo)
		
	
	
	if len(atributosNumerico) > 0:		
		for atributo in atributosNumerico:
			nuevoAtributo = ValoresNumerico()	
			nuevoAtributo.nombreAtributo = atributo.nombreAtributo
			nuevoAtributo.valor = atributo.valor
			nuevoAtributo.item_id = nuevoItem.id
			nuevoAtributo.version_item = nuevoItem.version		
			session.add(nuevoAtributo)
			
	if len(atributosArchivo) > 0:		
		for atributo in atributosArchivo:
			nuevoAtributo = ValoresArchivo()	
			nuevoAtributo.nombreAtributo = atributo.nombreAtributo
			nuevoAtributo.valor = atributo.valor
			nuevoAtributo.item_id = nuevoItem.id
			nuevoAtributo.version_item = nuevoItem.version
			nuevoAtributo.nombreArchivo = atributo.nombreArchivo		
			session.add(nuevoAtributo)
				
	#Hojoooooo
	#cambiar lo de abajoooo
	#
	#

	#una vez que hemos editado el item, marcamos todos los demás items dependientes para su revisión
	#marcar_item_to_revision(request.params['idItem'])

	#reproduciomos las relaciones del item
	#reproducir_relaciones_al_editar(request.params['idItem'], nuevoItem.id)

	#responseEdit = Response()
	#responseView.body = json.dumps(dict(success = True, atributos = [{'nombre':'Nombre', 'tipo': 'Cadena'}, {'nombre':'Fecha Inicio', 'tipo': 'Fecha'}]))
	#responseEdit.body = json.dumps(dict(success = True))
	#responseEdit.content_type = 'text/html'

	return nuevoItem
	
	
	
def reproducir_relacionesCrearRelacionPadreHijo(itemID, nuevoItemID, flagDelRelacion, session):
	
	#session = DBSession()
	
	antecesoresIDs = DBSession.query(RelacionA_S.antecesor).filter_by(sucesor = itemID).all()
	sucesoresIDs = DBSession.query(RelacionA_S.sucesor).filter_by(antecesor = itemID).all()
	
	hijosIDs = DBSession.query(RelacionP_H.hijo).filter_by(padre = itemID).all() 
	padresIDs = DBSession.query(RelacionP_H.padre).filter_by(hijo = itemID).all() 
	

	item_recibido = DBSession.query(Item).filter_by(id = itemID).one()

	#reproducimos las relaciones con sus antecesores
	for destinoID in antecesoresIDs:
		
		item_destino = DBSession.query(Item).filter_by(id=destinoID[0]).one()
		
		#por las dudas
		if item_destino.flagBorrado == 0 and item_destino.flagUltimo == 1:
			relacionAntecesor = RelacionA_S()
			relacionAntecesor.antecesor = item_destino.id
			relacionAntecesor.sucesor = nuevoItemID
			relacionAntecesor.duenho = nuevoItemID
			
			session.add(relacionAntecesor)
	   
		
	#reproducimos las relaciones con sus sucesores
	#comente porque no se puede dar el caso, no puede estar siendo editado y tener sucesores
	'''for destinoID in sucesoresIDs:
		
		item_destino = DBSession.query(Item).filter_by(id=destinoID[0]).one()

		#por las dudas
		if item_destino.flagBorrado == 0 and item_destino.flagUltimo == 1:
			relacionSucesor = RelacionA_S()
			relacionSucesor.antecesor = nuevoItemID
			relacionSucesor.sucesor = item_destino.id
			relacionSucesor.duenho = item_destino.id
			
			session.add(relacionSucesor)'''					   
	
	
	#reproducimos las relaciones con sus hijos	
	#esto ahora si se puede dar, porque se saca la restriccion de que el padre solamente pueda estar APROBADO
	for destinoID in hijosIDs:
		
		item_destino = DBSession.query(Item).filter_by(id=destinoID[0]).one()
		
		#por las dudas
		if item_destino.flagBorrado == 0 and item_destino.flagUltimo == 1:
			relacionHijo = RelacionP_H()
			relacionHijo.padre = nuevoItemID
			relacionHijo.hijo = item_destino.id
			relacionHijo.duenho = item_destino.id
			
			session.add(relacionHijo)
		
		
							  
	#reproducimos la relaciones con sus Padres, en relidad solo puede tener un padre	
	#si se crea la relacion esto no debe hacer, si es una eliminacion o edicion si
	if flagDelRelacion is True:
		
		print '>>>>entre en el if de flagDelRelacion'
		
		for destinoID in padresIDs:
			
			item_destino = DBSession.query(Item).filter_by(id=destinoID[0]).one()
		
			#por las dudas
			if item_destino.flagBorrado == 0 and item_destino.flagUltimo == 1:
				relacionPadre = RelacionP_H()
				relacionPadre.padre = item_destino.id
				relacionPadre.hijo = nuevoItemID
				relacionPadre.duenho = nuevoItemID
				
				print '>>>>reproduje el padreeeee'
				print '>>>>relacionPadre.padre'
				print relacionPadre.padre
				print '>>>>relacionPadre.hijo'
				print relacionPadre.hijo
				
				
				session.add(relacionPadre)	
		

def marcar_item_to_revision(itemID):
	
	antecesoresIDs = DBSession.query(RelacionA_S.antecesor).filter_by(sucesor = itemID).all()
	#sucesoresIDs = DBSession.query(RelacionA_S.sucesor).filter_by(antecesor = itemID).all()
	
	hijosIDs = DBSession.query(RelacionP_H.hijo).filter_by(padre = itemID).all() 
	padresIDs = DBSession.query(RelacionP_H.padre).filter_by(hijo = itemID).all() 
	
	destinosIDs = antecesoresIDs + hijosIDs + padresIDs
	
	for destinoID in destinosIDs:
		item_destino = DBSession.query(Item).filter_by(id=destinoID[0]).one()
		#marcamos el item para su revisión, si es una version actual y no borrada
		if item_destino.flagBorrado == 0 and item_destino.flagUltimo == 1:		
			item_destino.flagRevisar = 1
			#si el item esta en una linea base cambiamos el estado del mismo
			if item_destino.linea_base_id is not None:
				laLineaBase = DBSession.query(Linea_Base).filter_by(id=item_destino.linea_base_id).one()
				laLineaBase.estado = 'REVISION'''	
	

def reproducir_relacionesCrearRelacionAntecesorSucesor(itemID, nuevoItemID, session):
	
	#session = DBSession()
	
	antecesoresIDs = DBSession.query(RelacionA_S.antecesor).filter_by(sucesor = itemID).all()
	sucesoresIDs = DBSession.query(RelacionA_S.sucesor).filter_by(antecesor = itemID).all()
	
	hijosIDs = DBSession.query(RelacionP_H.hijo).filter_by(padre = itemID).all() 
	padresIDs = DBSession.query(RelacionP_H.padre).filter_by(hijo = itemID).all() 
	

	item_recibido = DBSession.query(Item).filter_by(id = itemID).one()

	#reproducimos las relaciones con sus antecesores
	for destinoID in antecesoresIDs:
		
		item_destino = DBSession.query(Item).filter_by(id=destinoID[0]).one()
		
		#por las dudas
		if item_destino.flagBorrado == 0 and item_destino.flagUltimo == 1:
			relacionAntecesor = RelacionA_S()
			relacionAntecesor.antecesor = item_destino.id
			relacionAntecesor.sucesor = nuevoItemID
			relacionAntecesor.duenho = nuevoItemID
			
			session.add(relacionAntecesor)
	   
		
	#reproducimos las relaciones con sus sucesores
	#comente porque no se puede dar el caso, no puede estar siendo editado y tener sucesores
	'''for destinoID in sucesoresIDs:
		
		item_destino = DBSession.query(Item).filter_by(id=destinoID[0]).one()

		#por las dudas
		if item_destino.flagBorrado == 0 and item_destino.flagUltimo == 1:
			relacionSucesor = RelacionA_S()
			relacionSucesor.antecesor = nuevoItemID
			relacionSucesor.sucesor = item_destino.id
			relacionSucesor.duenho = item_destino.id
			
			session.add(relacionSucesor)'''					   
	
	
	#reproducimos las relaciones con sus hijos	
	#esto ahora si se puede dar, porque se saca la restriccion de que el padre solamente pueda estar APROBADO
	for destinoID in hijosIDs:
		
		item_destino = DBSession.query(Item).filter_by(id=destinoID[0]).one()
		
		#por las dudas
		if item_destino.flagBorrado == 0 and item_destino.flagUltimo == 1:
			relacionHijo = RelacionP_H()
			relacionHijo.padre = nuevoItemID
			relacionHijo.hijo = item_destino.id
			relacionHijo.duenho = item_destino.id
			
			session.add(relacionHijo)
		
		
							  
	#reproducimos la relaciones con sus Padres, en relidad solo puede tener un padre	
	for destinoID in padresIDs:
		
		item_destino = DBSession.query(Item).filter_by(id=destinoID[0]).one()
	
		#por las dudas
		if item_destino.flagBorrado == 0 and item_destino.flagUltimo == 1:
			relacionPadre = RelacionP_H()
			relacionPadre.padre = item_destino.id
			relacionPadre.hijo = nuevoItemID
			relacionPadre.duenho = nuevoItemID
			
			session.add(relacionPadre)

